home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Archivers / CompDisk / CompSub.c < prev    next >
Text File  |  1996-09-26  |  5KB  |  354 lines
  1. long __regargs    memwrite(char *,long);
  2. void        compexit(void);
  3. long        compinit(void);
  4. long __regargs    compfiles(unsigned char *,long,unsigned char *,long);
  5. long        compress(void);
  6. void __regargs    output(long);
  7. void        cl_block(void);
  8. void        cl_hash(long);
  9.  
  10. #define BITS 12
  11.  
  12. #if BITS == 16
  13. #    define HSIZE    69001 
  14. #endif
  15. #if BITS == 15
  16. #    define HSIZE    35023 
  17. #endif
  18. #if BITS == 14
  19. #    define HSIZE    18013 
  20. #endif
  21. #if BITS == 13
  22. #    define HSIZE    9001 
  23. #endif
  24. #if BITS <= 12
  25. #    define HSIZE    5003 
  26. #endif
  27.  
  28. #define BLOCK_MASK    0x80
  29. #define INIT_BITS    9 
  30. #define htabof(i)    htab[i]
  31. #define codetabof(i)    codetab[i]
  32. #define MAXCODE(n_bits)    ((1 << (n_bits)) - 1)
  33. #define CHECK_GAP    10000
  34. #define FIRST        257 
  35. #define CLEAR        256 
  36.  
  37. #define myfgetc()    (reallyread++ >= watermark) ? EOF : *sect++
  38. #define absmin(a,b)    ((a > b) ? b : a)
  39.  
  40. long n_bits,maxcode,*htab,hsize,free_ent,clear_flg,ratio,checkpoint,offset,in_count,bytes_out,reallywritten,watermark,buffsize,reallyread;
  41.  
  42. unsigned char *buffstart,*sect;
  43. unsigned short *codetab;
  44.  
  45. char buf[BITS];
  46.  
  47. const unsigned char lmask[9] = {0xFF,0xFE,0xFC,0xF8,0xF0,0xE0,0xC0,0x80,0x00};
  48. const unsigned char rmask[9] = {0x00,0x01,0x03,0x07,0x0F,0x1F,0x3F,0x7F,0xFF};
  49.  
  50. long __regargs
  51. memwrite(mem,size)
  52. register char *mem;
  53. register long size;
  54. {
  55.     register long byteswritten = 0;
  56.  
  57.     while(size-- > 0)
  58.     {
  59.         if(reallywritten++ < buffsize)
  60.         {
  61.             *buffstart++ = *mem++;
  62.             byteswritten++;
  63.         }
  64.         else
  65.             return(byteswritten);
  66.     }
  67.  
  68.     return(byteswritten);
  69. }
  70.  
  71. void
  72. compexit()
  73. {
  74.     if(htab)
  75.         FreeMem(htab,HSIZE * sizeof(long));
  76.  
  77.     if(codetab)
  78.         FreeMem(codetab,HSIZE * sizeof(unsigned short));
  79.  
  80.     htab = NULL;
  81.     codetab = NULL;
  82. }
  83.  
  84. long
  85. compinit()
  86. {
  87.     if(!(htab = (long *)AllocMem(HSIZE * sizeof(long),0)))
  88.         return(FALSE);
  89.  
  90.     if(!(codetab = (unsigned short *)AllocMem(HSIZE * sizeof(unsigned short),0)))
  91.     {
  92.         FreeMem(htab,HSIZE * sizeof(long));
  93.  
  94.         htab = NULL;
  95.  
  96.         return(FALSE);
  97.     }
  98.  
  99.     return(TRUE);
  100. }
  101.  
  102. void __regargs
  103. output(code)
  104. long code;
  105. {
  106.     long r_off = offset, bits = n_bits;
  107.     register char *bp = buf;
  108.  
  109.     if(code >= 0)
  110.     {
  111.         bp += (r_off >> 3);
  112.         r_off &= 7;
  113.  
  114.         *bp = (*bp & rmask[r_off]) | (code << r_off) & lmask[r_off];
  115.         bp++;
  116.  
  117.         bits -= (8 - r_off);
  118.         code >>= 8 - r_off;
  119.  
  120.         if(bits >= 8)
  121.         {
  122.             *bp++ = code;
  123.             code >>= 8;
  124.             bits -= 8;
  125.         }
  126.  
  127.         if(bits)
  128.             *bp = code;
  129.  
  130.         offset += n_bits;
  131.  
  132.         if(offset == (n_bits << 3))
  133.         {
  134.             bp = buf;
  135.             bits = n_bits;
  136.             bytes_out += bits;
  137.  
  138.             do
  139.             {
  140.                 if(reallywritten++ < buffsize)
  141.                     *buffstart++ = *bp++;
  142.             }
  143.             while(--bits);
  144.  
  145.             offset = 0;
  146.         }
  147.  
  148.         if(free_ent > maxcode || (clear_flg > 0))
  149.         {
  150.             if(offset > 0)
  151.             {
  152.                 memwrite(buf,n_bits);
  153.                 bytes_out += n_bits;
  154.             }
  155.  
  156.             offset = 0;
  157.  
  158.             if(clear_flg)
  159.             {
  160.                 maxcode = MAXCODE(n_bits = INIT_BITS);
  161.                 clear_flg = 0;
  162.             }
  163.             else
  164.             {
  165.                 n_bits++;
  166.  
  167.                 if(n_bits == BITS)
  168.                     maxcode = (1 << BITS);
  169.                 else
  170.                     maxcode = MAXCODE(n_bits);
  171.             }
  172.         }
  173.     }
  174.     else
  175.     {
  176.         if(offset > 0)
  177.             memwrite(buf,(offset + 7) / 8);
  178.  
  179.         bytes_out += (offset + 7) / 8;
  180.         offset = 0;
  181.     }
  182. }
  183.  
  184. void
  185. cl_block()
  186. { 
  187.     register long rat;
  188.  
  189.     checkpoint = in_count + CHECK_GAP;
  190.  
  191.     if(in_count > 0x007FFFFF)
  192.     {
  193.         rat = bytes_out >> 8;
  194.  
  195.         if(rat == 0)
  196.             rat = 0x7FFFFFFF;
  197.         else
  198.             rat = in_count /rat;
  199.     }
  200.     else
  201.         rat = (in_count << 8) / bytes_out; 
  202.  
  203.     if(rat > ratio)
  204.         ratio = rat;
  205.     else
  206.     {
  207.         ratio = 0;
  208.  
  209.         cl_hash((long)hsize);
  210.  
  211.         free_ent = FIRST;
  212.         clear_flg = 1;
  213.  
  214.         output((long)CLEAR);
  215.     }
  216. }
  217.  
  218. void
  219. cl_hash(hashsize) 
  220. long hashsize;
  221. {
  222.     register long *htab_p = &htab[hashsize],i;
  223.     register unsigned short j;
  224.  
  225.     i = hashsize - 16;
  226.  
  227.     do
  228.     {
  229.         for(j = 16 ; j > 0 ; j--)
  230.             *(htab_p - j) = -1;
  231.  
  232.         htab_p -= 16;
  233.     }
  234.     while((i -= 16) >= 0);
  235.  
  236.     for(i += 16 ; i > 0 ; i--)
  237.         *--htab_p = -1;
  238. }
  239.  
  240. long __regargs
  241. compfiles(from,sectsize,to,maxsize)
  242. unsigned char *from,*to;
  243. long sectsize,maxsize;
  244. {
  245.     sect        = from;
  246.     watermark    = sectsize;
  247.     buffstart    = to;
  248.     buffsize    = maxsize;
  249.     reallywritten    = 0;
  250.     reallyread    = 0;
  251.  
  252.     hsize        = HSIZE;
  253.     free_ent    = 0;
  254.     clear_flg    = 0;
  255.     ratio        = 0;
  256.     checkpoint    = CHECK_GAP;
  257.     in_count    = 1; 
  258.  
  259.     if(sectsize < (1 << 12))
  260.         hsize = absmin(5003, HSIZE);
  261.     else if(sectsize < (1 << 13))
  262.         hsize = absmin(9001, HSIZE);
  263.     else if(sectsize < (1 << 14))
  264.         hsize = absmin(18013, HSIZE);
  265.     else if(sectsize < (1 << 15))
  266.         hsize = absmin(35023, HSIZE);
  267.     else if(sectsize < 47000)
  268.         hsize = absmin(50021, HSIZE);
  269.  
  270.     compress();
  271.  
  272.     return(reallywritten);
  273. }
  274.  
  275. long
  276. compress()
  277. {
  278.     long fcode,i = 0,c,ent,disp,hsize_reg,hshift = 0;
  279.  
  280.     offset        = 0;
  281.     bytes_out    = 3; 
  282.     clear_flg    = 0;
  283.     ratio        = 0;
  284.     in_count    = 1;
  285.  
  286.     checkpoint = CHECK_GAP;
  287.     maxcode = MAXCODE(n_bits = INIT_BITS);
  288.  
  289.     free_ent = ((BLOCK_MASK) ? FIRST : 256);
  290.  
  291.     ent = myfgetc();
  292.  
  293.     for(fcode = (long)hsize ; fcode < 65536L ; fcode *= 2L)
  294.         hshift++;
  295.  
  296.     hshift = 8 - hshift; 
  297.     hsize_reg = hsize;
  298.  
  299.     cl_hash((long)hsize_reg); 
  300.  
  301.     while((c = myfgetc()) != EOF)
  302.     {
  303.         in_count++;
  304.  
  305.         fcode = (long)(((long) c << BITS) + ent);
  306.  
  307.         i = ((c << hshift) ^ ent); 
  308.  
  309.         if(htabof(i) == fcode)
  310.         {
  311.             ent = codetabof(i);
  312.             continue;
  313.         }
  314.         else
  315.             if((long)htabof(i) < 0) 
  316.                 goto nomatch;
  317.  
  318.         disp = hsize_reg - i; 
  319.  
  320.         if(i == 0)
  321.             disp = 1;
  322.  
  323. probe:        if((i -= disp) < 0)
  324.             i += hsize_reg;
  325.  
  326.         if(htabof(i) == fcode)
  327.         {
  328.             ent = codetabof(i);
  329.             continue;
  330.         }
  331.  
  332.         if((long)htabof(i) > 0)
  333.             goto probe;
  334.  
  335. nomatch:    output((long)ent);
  336.  
  337.         ent = c;
  338.  
  339.         if(free_ent < (1 << BITS))
  340.         {
  341.             codetabof(i) = free_ent++; 
  342.             htabof(i) = fcode;
  343.         }
  344.         else
  345.             if((long)in_count >= checkpoint && BLOCK_MASK)
  346.                 cl_block();
  347.     }
  348.  
  349.     output((long)ent);
  350.     output((long)-1);
  351.  
  352.     return(bytes_out);
  353. }
  354.